﻿#include<iostream>
#include<vector>
#include<map>
//#include<string>
#include<algorithm>
#include<assert.h>
#include<string.h>
#include<list>

//#include"List.h"

using namespace std;

//struct Point
//{
//	int _x;
//	int _y;
//};
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//		:_year(year)
//		, _month(month)
//		, _day(day)
//	{
//		cout << "Date(int year, int month, int day)" << ':'
//			 <<year<<" "<<month<<" "<<day<<endl;
//	}
//	Date(const Date& d)
//		:_year(d._year)
//		, _month(d._month)
//		, _day(d._day)
//	{
//		cout << "Date(const Date& d)" << ':'
//			<< d._year << " " << d._month << " " << d._day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//void fun(int& x)
//{
//	cout << "左值引用 fun(int& x)" << endl;
//}
//
//void fun(const int& x)
//{
//	cout << "const左值引用 fun(const int& x)" << endl;
//}
//
//void fun(int&& x)
//{
//	cout << "右值引用 fun(int&& x)" << endl;
//}
//
//void fun(const int&& x)
//{
//	cout<<"const右值引用 fun(const int&& x)" << endl;
//}

//int main()
//{
	//列表初始化
	/*int x = { 1 };
	int y{ 1 };
	int a[] = { 6,7,8,9,0 };
	struct Point pi = { 4,5 };
	cout << x << " " << y << endl;
	cout << pi._x << " " << pi._y << endl;
	for (auto& e : a)
	{
		cout << e << " ";
	}
	cout << endl;*/

	//Date d1 = { 2024,1,2 };
	//Date d2{ 2024,1,3 };
	//Date d3{ 2027 };
	//Date d4 = 2030;

	//vector<Date> v;
	////有名对象，拷贝构造
	//v.push_back(d1);

	////匿名对象，构造+拷贝构造
	//v.push_back(Date(2025, 1, 1));

	////临时变量，构造+拷贝构造
	//v.push_back({ 2027,1,4 });

	//std::initializer_list<int> mylist;
	//mylist = { 10, 20, 30 };
	//cout << sizeof(mylist) << endl;
	//// 这⾥begin和end返回的值initializer_list对象中存的两个指针
	//// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
	//int i = 0;
	//cout << mylist.begin() << endl;
	//cout << mylist.end() << endl;
	//cout << &i << endl;
	//// {}列表中可以有任意多个值
	//// 这两个写法语义上还是有差别的，第⼀个v1是直接构造，
	//// 第⼆个v2是构造临时对象+临时对象拷⻉v2+优化为直接构造
	//vector<int> v1({ 1,2,3,4,5 });
	//vector<int> v2 = { 1,2,3,4,5 };
	//const vector<int>& v3 = { 1,2,3,4,5 };
	//// 这⾥是pair对象的{}初始化和map的initializer_list构造结合到⼀起⽤了
	//map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };
	//// initializer_list版本的赋值⽀持
	//v1 = { 10,20,30,40,50 };

	//左值可以取地址
	//int* p = new int(0);
	//int b = 1;
	//const int c = b;
	//*p = 10;
	//string s("111111");
	//s[0] = 'x';
	//cout << &c << endl;
	//cout << (void*)&s[0] << endl;

	//double x = 1.1, y = 2.2;
	////右值不能取地址
	//10;
	//x + y;
	////匿名对象
	//string("11111");

	////cout << &10 << endl;

	////右值引用引用右值，属性是左值，可以取地址
	//int&& r1 = 10;
	//cout << &r1 << endl;

	//string s1 = "Test";
	////string&& r1 = s1; // 错误：不能绑定到左值

	//const std::string& r2 = s1 + s1; // OK：到 const 的左值引⽤延⻓⽣存期
	////r2 += "Test"; // 错误：不能通过到 const 的引⽤修改

	//string&& r3 = s1 + s1; // OK：右值引⽤延⻓⽣存期 
	//r3 += "Test"; // OK：能通过到⾮ const 的引⽤修改

	//cout << r3 << endl;

	//左值引用和右值引用的参数匹配
	/*int i = 1;
	const int j = 2;
	fun(i);
	fun(j);

	int&& r1 = 3;
	const int&& r2 = 4;
	fun(3);
	fun(move(i));
	fun(r1);
	fun(r2);*/

	/*return 0;
}*/
//
namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str)-构造" << endl;
			_str = new char[_capacity + 1];
			//(_str, str);
		}

		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷⻉构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		// 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}

		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}

		~string()
		{
			cout << "~string() -- 析构" << endl;
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				if (_str)
				{
					//strcpy(tmp, _str);
					delete[] _str;
				}
				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
					2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}

private:
	char* _str = nullptr;
	size_t _size = 0;
	size_t _capacity = 0;
};
}

//int main()
//{
//	////构造 
//	//bit::string s1("xxxxx");
//
//	////拷贝构造
//	//bit::string s2 = s1;
//
//	////隐式类型转化 + 构造 + 拷贝构造  优化成为：直接构造
//	//bit::string s3 = bit::string("yyyyy");
//
//	////移动构造
//	//bit::string s4 = move(s1);
//
//	//移动构造和移动赋值的效率高于拷贝构造和拷贝赋值
//
//	std::list<bit::string> lt;
//
//	//构造+拷贝构造
//	bit::string s1("111111111111111111111");
//	lt.push_back(s1);
//	cout << "*************************" << endl;
//
//	//匿名对象————>构造+移动构造
//	lt.push_back(bit::string("22222222222222222222222222222"));
//	cout << "*************************" << endl;
//
//	//隐式类型转化的临时对象————>构造+移动构造
//	lt.push_back("3333333333333333333333333333");
//	cout << "*************************" << endl;
//
//	//移动构造
//	lt.push_back(move(s1));
//	cout << "*************************" << endl;
//	
//	return 0;
//}

namespace bit
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _data;

		ListNode(const T& data = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(data)
		{
		}

		ListNode(T&& data)
			:_next(nullptr)
			, _prev(nullptr)
			, _data(move(data))
		{
		}
	};

	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		Node* _node;

		ListIterator(Node* node)
			:_node(node)
		{
		}

		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}

	};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;
		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}

		list()
		{
			empty_init();
		}

		void push_back(const T& x)
		{
			insert(end(), x);
		}

		void push_back(T&& x)
		{
			insert(end(), move(x));
		}

		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}

		iterator insert(iterator pos, T && x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(move(x));
			Node* prev = cur->_prev;
			// prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return iterator(newnode);
		}

	private:
		Node* _head;
	};
}

//int main()
//{
//	bit::list<bit::string> lt;
//	cout << "*************************" << endl;
//
//	////构造+拷贝构造
//	//bit::string s1("111111111111111111111");
//	//lt.push_back(s1);
//	//cout << "*************************" << endl;
//
//	//移动构造
//	lt.push_back(bit::string("22222222222222222222222222222"));
//	cout << "*************************" << endl;
//
//	//移动构造
//	lt.push_back("3333333333333333333333333333");
//	cout << "*************************" << endl;
//
//	////移动构造
//	//lt.push_back(move(s1));
//	//cout << "*************************" << endl;
//	return 0;
//}

// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤
//template<class T>
//void f1(T& x)
//{
//}
//
//// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤
//template<class T>
//void f2(T&& x)
//{
//}
//
//int main()
//{
//	//引用折叠：
//	// 左引用 + 左引用/右引用 = 左引用
//	// 右引用 + 右引用       = 右引用 
//
//	typedef int& lref;
//	typedef int&& rref;
//	int n = 0;
//	lref& r1 = n; // r1 的类型是 int&
//	lref&& r2 = n; // r2 的类型是 int&
//	rref& r3 = n; // r3 的类型是 int&
//	rref&& r4 = 1; // r4 的类型是 int&&
//	// 没有折叠->实例化为void f1(int& x)
//
//	//特例T为int，int&可以引用左值
//	f1<int>(n);
//
//	//特例T为int，int&不可以引用右值
//	//f1<int>(0); // 报错
//
//	// 折叠->实例化为void f1(int& x)
//
//	//特例T为int& 左 + 左 = 左
//	f1<int&>(n);
//
//	//特例T为int& 右 + 右 = 右，左值引用不可引用右值
//	//f1<int&>(0); // 报错
//
//	// 折叠->实例化为void f1(int& x)
//	f1<int&&>(n);
//	//f1<int&&>(0); // 报错
//
//	// 折叠->实例化为void f1(const int& x)
//	f1<const int&>(n);
//	f1<const int&>(0);
//
//	// 折叠->实例化为void f1(const int& x)
//	f1<const int&&>(n);
//	f1<const int&&>(0);
//
//	// 没有折叠->实例化为void f2(int&& x)
//	//f2<int>(n); // 报错
//	f2<int>(0);
//
//	// 折叠->实例化为void f2(int& x)
//	f2<int&>(n);
//	//f2<int&>(0); // 报错
//
//	// 折叠->实例化为void f2(int&& x)
//	//f2<int&&>(n); // 报错
//	f2<int&&>(0);
//
//	return 0;
//}

//

//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//
//template<class T>
//void Function(T&& t)
//{
//	//Fun(t);
//	Fun(forward<T>(t));
//}
//
//int main()
//{
//	//Fun(t)结果：左值引用，Fun(forward<T>(t))：右值引用
//	Function(10);
//
//	int a;
//	//Fun(t)结果：左值引用，Fun(forward<T>(t))：左值引用
//	Function(a);
//	//Fun(t)结果：左值引用，Fun(forward<T>(t))：右值引用
//	Function(std::move(a));
//
//	const int b = 8;
//	//Fun(t)结果：const左值引用，Fun(forward<T>(t))：const左值引用
//	Function(b);
//
//	//Fun(t)结果：const左值引用，Fun(forward<T>(t))：const右值引用
//	Function(std::move(b));
//	return 0;
//}

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }

void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<class T>
void Function(T&& t)
{
	//Fun(t);
	Fun(forward<T>(t));
}

//int main()
//{
//	// 10是右值，推导出T为int，模板实例化为void Function(int&& t)
//	Function(10); // 右值
//
//	int a;
//	// a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t)
//	Function(a); // 左值
//
//	// std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
//	Function(std::move(a)); // 右值
//
//	const int b = 8;
//	// a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
//	Function(b); // const 左值
//
//	// std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//	Function(std::move(b)); // const 右值
//
//	return 0;
//}

//template <class ...Args>
//void Print(Args&&... args)
//{
//	cout << sizeof...(args) << endl;
//}
//
//int main()
//{
//	double x = 2.2;
//	Print(); // 包⾥有0个参数
//	Print(1); // 包⾥有1个参数
//	Print(1, string("xxxxx")); // 包⾥有2个参数
//	Print(1.1, string("xxxxx"), x); // 包⾥有3个参数
//
//	return 0;
//}

void ShowList()
{
	// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数
	cout << endl;
}

template <class T, class ...Args>
void ShowList(T x, Args... args)
{
	cout << x << " ";
	// args是N个参数的参数包
	// 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包
	ShowList(args...);
}

// Print()函数的Args的参数个数比ShowList()多一个，ShowList()中的T x是Print()中参数列表的第一个

// 编译时递归推导解析参数
template <class ...Args>
void Print(Args... args)
{
	ShowList(args...);
}

//int main()
//{
//	Print();
//	Print(1);
//	Print(1, string("xxxxx"));
//	Print(1, string("xxxxx"), 2.2);
//
//	return 0;
//}

int main()
{
	// ⼀个简单的lambda表达式
	auto add1 = [](int x, int y)->int {return x + y; };
	cout << add1(1, 2) << endl;

	// 1、捕捉为空也不能省略
	// 2、参数为空可以省略
	// 3、返回值可以省略，可以通过返回对象⾃动推导
	// 4、函数体不能省略
	auto func1 = []
		{
			cout << "hello world" << endl;
			return 0;
		};

	func1();

	int a = 0, b = 1;
	auto swap1 = [](int& x, int& y)
		{
			int tmp = x;
			x = y;
			y = tmp;
		};
	swap1(a, b);
	cout << a << ":" << b << endl;

	return 0;
}

